// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.inventory.model;

import com.fowo.api.common.model.PageSearch;
import java.util.Date;
import java.util.List;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class InventoryPlacementVariationSearchParamPo extends PageSearch {

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 仓库内码
   */
  private Long stockId;

  /**
   * 最小仓库内码
   */
  private Long stockIdMin;

  /**
   * 最大仓库内码
   */
  private Long stockIdMax;

  /**
   * 仓库内码 比较(eq)
   */
  private Long stockIdEq;
  /**
   * 仓库内码 比较(neq)
   */
  private Long stockIdNeq;
  /**
   * 仓库内码 比较(gt)
   */
  private Long stockIdGt;
  /**
   * 仓库内码 比较(gte)
   */
  private Long stockIdGte;
  /**
   * 仓库内码 比较(lt)
   */
  private Long stockIdLt;
  /**
   * 仓库内码 比较(lte)
   */
  private Long stockIdLte;
  /**
   * 仓库内码 比较(contains)
   */
  private Long stockIdContains;
  /**
   * 仓库内码 比较(notcontains)
   */
  private Long stockIdNotcontains;
  /**
   * 仓库内码 比较(startswith)
   */
  private Long stockIdStartswith;
  /**
   * 仓库内码 比较(endswith)
   */
  private Long stockIdEndswith;
  /**
   * 仓库内码 比较(isnull)
   */
  private Boolean stockIdIsnull;
  /**
   * 仓库内码 比较(isnotnull)
   */
  private Boolean stockIdIsnotnull;

  /**
   * 项目内码
   */
  private Long projectId;

  /**
   * 最小项目内码
   */
  private Long projectIdMin;

  /**
   * 最大项目内码
   */
  private Long projectIdMax;

  /**
   * 项目内码 比较(eq)
   */
  private Long projectIdEq;
  /**
   * 项目内码 比较(neq)
   */
  private Long projectIdNeq;
  /**
   * 项目内码 比较(gt)
   */
  private Long projectIdGt;
  /**
   * 项目内码 比较(gte)
   */
  private Long projectIdGte;
  /**
   * 项目内码 比较(lt)
   */
  private Long projectIdLt;
  /**
   * 项目内码 比较(lte)
   */
  private Long projectIdLte;
  /**
   * 项目内码 比较(contains)
   */
  private Long projectIdContains;
  /**
   * 项目内码 比较(notcontains)
   */
  private Long projectIdNotcontains;
  /**
   * 项目内码 比较(startswith)
   */
  private Long projectIdStartswith;
  /**
   * 项目内码 比较(endswith)
   */
  private Long projectIdEndswith;
  /**
   * 项目内码 比较(isnull)
   */
  private Boolean projectIdIsnull;
  /**
   * 项目内码 比较(isnotnull)
   */
  private Boolean projectIdIsnotnull;

  /**
   * 物料内码
   */
  private Long itemId;

  /**
   * 最小物料内码
   */
  private Long itemIdMin;

  /**
   * 最大物料内码
   */
  private Long itemIdMax;

  /**
   * 物料内码 比较(eq)
   */
  private Long itemIdEq;
  /**
   * 物料内码 比较(neq)
   */
  private Long itemIdNeq;
  /**
   * 物料内码 比较(gt)
   */
  private Long itemIdGt;
  /**
   * 物料内码 比较(gte)
   */
  private Long itemIdGte;
  /**
   * 物料内码 比较(lt)
   */
  private Long itemIdLt;
  /**
   * 物料内码 比较(lte)
   */
  private Long itemIdLte;
  /**
   * 物料内码 比较(contains)
   */
  private Long itemIdContains;
  /**
   * 物料内码 比较(notcontains)
   */
  private Long itemIdNotcontains;
  /**
   * 物料内码 比较(startswith)
   */
  private Long itemIdStartswith;
  /**
   * 物料内码 比较(endswith)
   */
  private Long itemIdEndswith;
  /**
   * 物料内码 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 物料内码 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;

  /**
   * 批号(模糊搜索)
   */
  private String batchNo;

  /**
   * 批号 比较(eq)
   */
  private String batchNoEq;
  /**
   * 批号 比较(neq)
   */
  private String batchNoNeq;
  /**
   * 批号 比较(gt)
   */
  private String batchNoGt;
  /**
   * 批号 比较(gte)
   */
  private String batchNoGte;
  /**
   * 批号 比较(lt)
   */
  private String batchNoLt;
  /**
   * 批号 比较(lte)
   */
  private String batchNoLte;
  /**
   * 批号 比较(contains)
   */
  private String batchNoContains;
  /**
   * 批号 比较(notcontains)
   */
  private String batchNoNotcontains;
  /**
   * 批号 比较(startswith)
   */
  private String batchNoStartswith;
  /**
   * 批号 比较(endswith)
   */
  private String batchNoEndswith;
  /**
   * 批号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 批号(精确搜索)
   */
  private List<String> batchNoInList;

  /**
   * 变动类型(模糊搜索)
   */
  private String changeType;

  /**
   * 变动类型 比较(eq)
   */
  private String changeTypeEq;
  /**
   * 变动类型 比较(neq)
   */
  private String changeTypeNeq;
  /**
   * 变动类型 比较(gt)
   */
  private String changeTypeGt;
  /**
   * 变动类型 比较(gte)
   */
  private String changeTypeGte;
  /**
   * 变动类型 比较(lt)
   */
  private String changeTypeLt;
  /**
   * 变动类型 比较(lte)
   */
  private String changeTypeLte;
  /**
   * 变动类型 比较(contains)
   */
  private String changeTypeContains;
  /**
   * 变动类型 比较(notcontains)
   */
  private String changeTypeNotcontains;
  /**
   * 变动类型 比较(startswith)
   */
  private String changeTypeStartswith;
  /**
   * 变动类型 比较(endswith)
   */
  private String changeTypeEndswith;
  /**
   * 变动类型 比较(isnull)
   */
  private Boolean changeTypeIsnull;
  /**
   * 变动类型 比较(isnotnull)
   */
  private Boolean changeTypeIsnotnull;

  /**
   * 变动类型(精确搜索)
   */
  private List<String> changeTypeInList;

  /**
   * 变动源类型(模糊搜索)
   */
  private String fromType;

  /**
   * 变动源类型 比较(eq)
   */
  private String fromTypeEq;
  /**
   * 变动源类型 比较(neq)
   */
  private String fromTypeNeq;
  /**
   * 变动源类型 比较(gt)
   */
  private String fromTypeGt;
  /**
   * 变动源类型 比较(gte)
   */
  private String fromTypeGte;
  /**
   * 变动源类型 比较(lt)
   */
  private String fromTypeLt;
  /**
   * 变动源类型 比较(lte)
   */
  private String fromTypeLte;
  /**
   * 变动源类型 比较(contains)
   */
  private String fromTypeContains;
  /**
   * 变动源类型 比较(notcontains)
   */
  private String fromTypeNotcontains;
  /**
   * 变动源类型 比较(startswith)
   */
  private String fromTypeStartswith;
  /**
   * 变动源类型 比较(endswith)
   */
  private String fromTypeEndswith;
  /**
   * 变动源类型 比较(isnull)
   */
  private Boolean fromTypeIsnull;
  /**
   * 变动源类型 比较(isnotnull)
   */
  private Boolean fromTypeIsnotnull;

  /**
   * 变动源类型(精确搜索)
   */
  private List<String> fromTypeInList;

  /**
   * 变动目标类型(模糊搜索)
   */
  private String toType;

  /**
   * 变动目标类型 比较(eq)
   */
  private String toTypeEq;
  /**
   * 变动目标类型 比较(neq)
   */
  private String toTypeNeq;
  /**
   * 变动目标类型 比较(gt)
   */
  private String toTypeGt;
  /**
   * 变动目标类型 比较(gte)
   */
  private String toTypeGte;
  /**
   * 变动目标类型 比较(lt)
   */
  private String toTypeLt;
  /**
   * 变动目标类型 比较(lte)
   */
  private String toTypeLte;
  /**
   * 变动目标类型 比较(contains)
   */
  private String toTypeContains;
  /**
   * 变动目标类型 比较(notcontains)
   */
  private String toTypeNotcontains;
  /**
   * 变动目标类型 比较(startswith)
   */
  private String toTypeStartswith;
  /**
   * 变动目标类型 比较(endswith)
   */
  private String toTypeEndswith;
  /**
   * 变动目标类型 比较(isnull)
   */
  private Boolean toTypeIsnull;
  /**
   * 变动目标类型 比较(isnotnull)
   */
  private Boolean toTypeIsnotnull;

  /**
   * 变动目标类型(精确搜索)
   */
  private List<String> toTypeInList;

  /**
   * 关联单据号(模糊搜索)
   */
  private String formNum;

  /**
   * 关联单据号 比较(eq)
   */
  private String formNumEq;
  /**
   * 关联单据号 比较(neq)
   */
  private String formNumNeq;
  /**
   * 关联单据号 比较(gt)
   */
  private String formNumGt;
  /**
   * 关联单据号 比较(gte)
   */
  private String formNumGte;
  /**
   * 关联单据号 比较(lt)
   */
  private String formNumLt;
  /**
   * 关联单据号 比较(lte)
   */
  private String formNumLte;
  /**
   * 关联单据号 比较(contains)
   */
  private String formNumContains;
  /**
   * 关联单据号 比较(notcontains)
   */
  private String formNumNotcontains;
  /**
   * 关联单据号 比较(startswith)
   */
  private String formNumStartswith;
  /**
   * 关联单据号 比较(endswith)
   */
  private String formNumEndswith;
  /**
   * 关联单据号 比较(isnull)
   */
  private Boolean formNumIsnull;
  /**
   * 关联单据号 比较(isnotnull)
   */
  private Boolean formNumIsnotnull;

  /**
   * 关联单据号(精确搜索)
   */
  private List<String> formNumInList;

  /**
   * 关联制单人(模糊搜索)
   */
  private String formOperator;

  /**
   * 关联制单人 比较(eq)
   */
  private String formOperatorEq;
  /**
   * 关联制单人 比较(neq)
   */
  private String formOperatorNeq;
  /**
   * 关联制单人 比较(gt)
   */
  private String formOperatorGt;
  /**
   * 关联制单人 比较(gte)
   */
  private String formOperatorGte;
  /**
   * 关联制单人 比较(lt)
   */
  private String formOperatorLt;
  /**
   * 关联制单人 比较(lte)
   */
  private String formOperatorLte;
  /**
   * 关联制单人 比较(contains)
   */
  private String formOperatorContains;
  /**
   * 关联制单人 比较(notcontains)
   */
  private String formOperatorNotcontains;
  /**
   * 关联制单人 比较(startswith)
   */
  private String formOperatorStartswith;
  /**
   * 关联制单人 比较(endswith)
   */
  private String formOperatorEndswith;
  /**
   * 关联制单人 比较(isnull)
   */
  private Boolean formOperatorIsnull;
  /**
   * 关联制单人 比较(isnotnull)
   */
  private Boolean formOperatorIsnotnull;

  /**
   * 关联制单人(精确搜索)
   */
  private List<String> formOperatorInList;

  /**
   * 操作业务名称(模糊搜索)
   */
  private String operate;

  /**
   * 操作业务名称 比较(eq)
   */
  private String operateEq;
  /**
   * 操作业务名称 比较(neq)
   */
  private String operateNeq;
  /**
   * 操作业务名称 比较(gt)
   */
  private String operateGt;
  /**
   * 操作业务名称 比较(gte)
   */
  private String operateGte;
  /**
   * 操作业务名称 比较(lt)
   */
  private String operateLt;
  /**
   * 操作业务名称 比较(lte)
   */
  private String operateLte;
  /**
   * 操作业务名称 比较(contains)
   */
  private String operateContains;
  /**
   * 操作业务名称 比较(notcontains)
   */
  private String operateNotcontains;
  /**
   * 操作业务名称 比较(startswith)
   */
  private String operateStartswith;
  /**
   * 操作业务名称 比较(endswith)
   */
  private String operateEndswith;
  /**
   * 操作业务名称 比较(isnull)
   */
  private Boolean operateIsnull;
  /**
   * 操作业务名称 比较(isnotnull)
   */
  private Boolean operateIsnotnull;

  /**
   * 操作业务名称(精确搜索)
   */
  private List<String> operateInList;

  /**
   * 关联唯一操作键(模糊搜索)
   */
  private String operateKey;

  /**
   * 关联唯一操作键 比较(eq)
   */
  private String operateKeyEq;
  /**
   * 关联唯一操作键 比较(neq)
   */
  private String operateKeyNeq;
  /**
   * 关联唯一操作键 比较(gt)
   */
  private String operateKeyGt;
  /**
   * 关联唯一操作键 比较(gte)
   */
  private String operateKeyGte;
  /**
   * 关联唯一操作键 比较(lt)
   */
  private String operateKeyLt;
  /**
   * 关联唯一操作键 比较(lte)
   */
  private String operateKeyLte;
  /**
   * 关联唯一操作键 比较(contains)
   */
  private String operateKeyContains;
  /**
   * 关联唯一操作键 比较(notcontains)
   */
  private String operateKeyNotcontains;
  /**
   * 关联唯一操作键 比较(startswith)
   */
  private String operateKeyStartswith;
  /**
   * 关联唯一操作键 比较(endswith)
   */
  private String operateKeyEndswith;
  /**
   * 关联唯一操作键 比较(isnull)
   */
  private Boolean operateKeyIsnull;
  /**
   * 关联唯一操作键 比较(isnotnull)
   */
  private Boolean operateKeyIsnotnull;

  /**
   * 关联唯一操作键(精确搜索)
   */
  private List<String> operateKeyInList;

  /**
   * 最早操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operateTimeStart;

  /**
   * 最晚操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operateTimeEnd;

  /**
   * 操作时间 比较(eq)
   */
  private Date operateTimeEq;
  /**
   * 操作时间 比较(neq)
   */
  private Date operateTimeNeq;
  /**
   * 操作时间 比较(gt)
   */
  private Date operateTimeGt;
  /**
   * 操作时间 比较(gte)
   */
  private Date operateTimeGte;
  /**
   * 操作时间 比较(lt)
   */
  private Date operateTimeLt;
  /**
   * 操作时间 比较(lte)
   */
  private Date operateTimeLte;
  /**
   * 操作时间 比较(contains)
   */
  private Date operateTimeContains;
  /**
   * 操作时间 比较(notcontains)
   */
  private Date operateTimeNotcontains;
  /**
   * 操作时间 比较(startswith)
   */
  private Date operateTimeStartswith;
  /**
   * 操作时间 比较(endswith)
   */
  private Date operateTimeEndswith;
  /**
   * 操作时间 比较(isnull)
   */
  private Boolean operateTimeIsnull;
  /**
   * 操作时间 比较(isnotnull)
   */
  private Boolean operateTimeIsnotnull;

  /**
   * 库位内码
   */
  private Long binId;

  /**
   * 最小库位内码
   */
  private Long binIdMin;

  /**
   * 最大库位内码
   */
  private Long binIdMax;

  /**
   * 库位内码 比较(eq)
   */
  private Long binIdEq;
  /**
   * 库位内码 比较(neq)
   */
  private Long binIdNeq;
  /**
   * 库位内码 比较(gt)
   */
  private Long binIdGt;
  /**
   * 库位内码 比较(gte)
   */
  private Long binIdGte;
  /**
   * 库位内码 比较(lt)
   */
  private Long binIdLt;
  /**
   * 库位内码 比较(lte)
   */
  private Long binIdLte;
  /**
   * 库位内码 比较(contains)
   */
  private Long binIdContains;
  /**
   * 库位内码 比较(notcontains)
   */
  private Long binIdNotcontains;
  /**
   * 库位内码 比较(startswith)
   */
  private Long binIdStartswith;
  /**
   * 库位内码 比较(endswith)
   */
  private Long binIdEndswith;
  /**
   * 库位内码 比较(isnull)
   */
  private Boolean binIdIsnull;
  /**
   * 库位内码 比较(isnotnull)
   */
  private Boolean binIdIsnotnull;

  /**
   * 店铺id(模糊搜索)
   */
  private String shopId;

  /**
   * 店铺id 比较(eq)
   */
  private String shopIdEq;
  /**
   * 店铺id 比较(neq)
   */
  private String shopIdNeq;
  /**
   * 店铺id 比较(gt)
   */
  private String shopIdGt;
  /**
   * 店铺id 比较(gte)
   */
  private String shopIdGte;
  /**
   * 店铺id 比较(lt)
   */
  private String shopIdLt;
  /**
   * 店铺id 比较(lte)
   */
  private String shopIdLte;
  /**
   * 店铺id 比较(contains)
   */
  private String shopIdContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private String shopIdNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private String shopIdStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private String shopIdEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;

  /**
   * 店铺id(精确搜索)
   */
  private List<String> shopIdInList;

  /**
   * fnSku(模糊搜索)
   */
  private String fnSku;

  /**
   * fnSku 比较(eq)
   */
  private String fnSkuEq;
  /**
   * fnSku 比较(neq)
   */
  private String fnSkuNeq;
  /**
   * fnSku 比较(gt)
   */
  private String fnSkuGt;
  /**
   * fnSku 比较(gte)
   */
  private String fnSkuGte;
  /**
   * fnSku 比较(lt)
   */
  private String fnSkuLt;
  /**
   * fnSku 比较(lte)
   */
  private String fnSkuLte;
  /**
   * fnSku 比较(contains)
   */
  private String fnSkuContains;
  /**
   * fnSku 比较(notcontains)
   */
  private String fnSkuNotcontains;
  /**
   * fnSku 比较(startswith)
   */
  private String fnSkuStartswith;
  /**
   * fnSku 比较(endswith)
   */
  private String fnSkuEndswith;
  /**
   * fnSku 比较(isnull)
   */
  private Boolean fnSkuIsnull;
  /**
   * fnSku 比较(isnotnull)
   */
  private Boolean fnSkuIsnotnull;

  /**
   * fnSku(精确搜索)
   */
  private List<String> fnSkuInList;

  /**
   * 保质期(天)
   */
  private Integer shelfLife;

  /**
   * 最小保质期(天)
   */
  private Integer shelfLifeMin;

  /**
   * 最大保质期(天)
   */
  private Integer shelfLifeMax;

  /**
   * 保质期(天) 比较(eq)
   */
  private Integer shelfLifeEq;
  /**
   * 保质期(天) 比较(neq)
   */
  private Integer shelfLifeNeq;
  /**
   * 保质期(天) 比较(gt)
   */
  private Integer shelfLifeGt;
  /**
   * 保质期(天) 比较(gte)
   */
  private Integer shelfLifeGte;
  /**
   * 保质期(天) 比较(lt)
   */
  private Integer shelfLifeLt;
  /**
   * 保质期(天) 比较(lte)
   */
  private Integer shelfLifeLte;
  /**
   * 保质期(天) 比较(contains)
   */
  private Integer shelfLifeContains;
  /**
   * 保质期(天) 比较(notcontains)
   */
  private Integer shelfLifeNotcontains;
  /**
   * 保质期(天) 比较(startswith)
   */
  private Integer shelfLifeStartswith;
  /**
   * 保质期(天) 比较(endswith)
   */
  private Integer shelfLifeEndswith;
  /**
   * 保质期(天) 比较(isnull)
   */
  private Boolean shelfLifeIsnull;
  /**
   * 保质期(天) 比较(isnotnull)
   */
  private Boolean shelfLifeIsnotnull;

  /**
   * 最早生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateStart;

  /**
   * 最晚生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateEnd;

  /**
   * 生产日期 比较(eq)
   */
  private Date productionDateEq;
  /**
   * 生产日期 比较(neq)
   */
  private Date productionDateNeq;
  /**
   * 生产日期 比较(gt)
   */
  private Date productionDateGt;
  /**
   * 生产日期 比较(gte)
   */
  private Date productionDateGte;
  /**
   * 生产日期 比较(lt)
   */
  private Date productionDateLt;
  /**
   * 生产日期 比较(lte)
   */
  private Date productionDateLte;
  /**
   * 生产日期 比较(contains)
   */
  private Date productionDateContains;
  /**
   * 生产日期 比较(notcontains)
   */
  private Date productionDateNotcontains;
  /**
   * 生产日期 比较(startswith)
   */
  private Date productionDateStartswith;
  /**
   * 生产日期 比较(endswith)
   */
  private Date productionDateEndswith;
  /**
   * 生产日期 比较(isnull)
   */
  private Boolean productionDateIsnull;
  /**
   * 生产日期 比较(isnotnull)
   */
  private Boolean productionDateIsnotnull;

  /**
   * 最早有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateStart;

  /**
   * 最晚有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateEnd;

  /**
   * 有效期至 比较(eq)
   */
  private Date expiryDateEq;
  /**
   * 有效期至 比较(neq)
   */
  private Date expiryDateNeq;
  /**
   * 有效期至 比较(gt)
   */
  private Date expiryDateGt;
  /**
   * 有效期至 比较(gte)
   */
  private Date expiryDateGte;
  /**
   * 有效期至 比较(lt)
   */
  private Date expiryDateLt;
  /**
   * 有效期至 比较(lte)
   */
  private Date expiryDateLte;
  /**
   * 有效期至 比较(contains)
   */
  private Date expiryDateContains;
  /**
   * 有效期至 比较(notcontains)
   */
  private Date expiryDateNotcontains;
  /**
   * 有效期至 比较(startswith)
   */
  private Date expiryDateStartswith;
  /**
   * 有效期至 比较(endswith)
   */
  private Date expiryDateEndswith;
  /**
   * 有效期至 比较(isnull)
   */
  private Boolean expiryDateIsnull;
  /**
   * 有效期至 比较(isnotnull)
   */
  private Boolean expiryDateIsnotnull;

  /**
   * 锁库数量
   */
  private java.math.BigDecimal lockQty;

  /**
   * 最小锁库数量
   */
  private java.math.BigDecimal lockQtyMin;

  /**
   * 最大锁库数量
   */
  private java.math.BigDecimal lockQtyMax;

  /**
   * 锁库数量 比较(eq)
   */
  private java.math.BigDecimal lockQtyEq;
  /**
   * 锁库数量 比较(neq)
   */
  private java.math.BigDecimal lockQtyNeq;
  /**
   * 锁库数量 比较(gt)
   */
  private java.math.BigDecimal lockQtyGt;
  /**
   * 锁库数量 比较(gte)
   */
  private java.math.BigDecimal lockQtyGte;
  /**
   * 锁库数量 比较(lt)
   */
  private java.math.BigDecimal lockQtyLt;
  /**
   * 锁库数量 比较(lte)
   */
  private java.math.BigDecimal lockQtyLte;
  /**
   * 锁库数量 比较(contains)
   */
  private java.math.BigDecimal lockQtyContains;
  /**
   * 锁库数量 比较(notcontains)
   */
  private java.math.BigDecimal lockQtyNotcontains;
  /**
   * 锁库数量 比较(startswith)
   */
  private java.math.BigDecimal lockQtyStartswith;
  /**
   * 锁库数量 比较(endswith)
   */
  private java.math.BigDecimal lockQtyEndswith;
  /**
   * 锁库数量 比较(isnull)
   */
  private Boolean lockQtyIsnull;
  /**
   * 锁库数量 比较(isnotnull)
   */
  private Boolean lockQtyIsnotnull;

  /**
   * 锁库数量变更
   */
  private java.math.BigDecimal changeLockQty;

  /**
   * 最小锁库数量变更
   */
  private java.math.BigDecimal changeLockQtyMin;

  /**
   * 最大锁库数量变更
   */
  private java.math.BigDecimal changeLockQtyMax;

  /**
   * 锁库数量变更 比较(eq)
   */
  private java.math.BigDecimal changeLockQtyEq;
  /**
   * 锁库数量变更 比较(neq)
   */
  private java.math.BigDecimal changeLockQtyNeq;
  /**
   * 锁库数量变更 比较(gt)
   */
  private java.math.BigDecimal changeLockQtyGt;
  /**
   * 锁库数量变更 比较(gte)
   */
  private java.math.BigDecimal changeLockQtyGte;
  /**
   * 锁库数量变更 比较(lt)
   */
  private java.math.BigDecimal changeLockQtyLt;
  /**
   * 锁库数量变更 比较(lte)
   */
  private java.math.BigDecimal changeLockQtyLte;
  /**
   * 锁库数量变更 比较(contains)
   */
  private java.math.BigDecimal changeLockQtyContains;
  /**
   * 锁库数量变更 比较(notcontains)
   */
  private java.math.BigDecimal changeLockQtyNotcontains;
  /**
   * 锁库数量变更 比较(startswith)
   */
  private java.math.BigDecimal changeLockQtyStartswith;
  /**
   * 锁库数量变更 比较(endswith)
   */
  private java.math.BigDecimal changeLockQtyEndswith;
  /**
   * 锁库数量变更 比较(isnull)
   */
  private Boolean changeLockQtyIsnull;
  /**
   * 锁库数量变更 比较(isnotnull)
   */
  private Boolean changeLockQtyIsnotnull;

  /**
   * 在途数量
   */
  private java.math.BigDecimal wayQty;

  /**
   * 最小在途数量
   */
  private java.math.BigDecimal wayQtyMin;

  /**
   * 最大在途数量
   */
  private java.math.BigDecimal wayQtyMax;

  /**
   * 在途数量 比较(eq)
   */
  private java.math.BigDecimal wayQtyEq;
  /**
   * 在途数量 比较(neq)
   */
  private java.math.BigDecimal wayQtyNeq;
  /**
   * 在途数量 比较(gt)
   */
  private java.math.BigDecimal wayQtyGt;
  /**
   * 在途数量 比较(gte)
   */
  private java.math.BigDecimal wayQtyGte;
  /**
   * 在途数量 比较(lt)
   */
  private java.math.BigDecimal wayQtyLt;
  /**
   * 在途数量 比较(lte)
   */
  private java.math.BigDecimal wayQtyLte;
  /**
   * 在途数量 比较(contains)
   */
  private java.math.BigDecimal wayQtyContains;
  /**
   * 在途数量 比较(notcontains)
   */
  private java.math.BigDecimal wayQtyNotcontains;
  /**
   * 在途数量 比较(startswith)
   */
  private java.math.BigDecimal wayQtyStartswith;
  /**
   * 在途数量 比较(endswith)
   */
  private java.math.BigDecimal wayQtyEndswith;
  /**
   * 在途数量 比较(isnull)
   */
  private Boolean wayQtyIsnull;
  /**
   * 在途数量 比较(isnotnull)
   */
  private Boolean wayQtyIsnotnull;

  /**
   * 在途数量变更
   */
  private java.math.BigDecimal changeWayQty;

  /**
   * 最小在途数量变更
   */
  private java.math.BigDecimal changeWayQtyMin;

  /**
   * 最大在途数量变更
   */
  private java.math.BigDecimal changeWayQtyMax;

  /**
   * 在途数量变更 比较(eq)
   */
  private java.math.BigDecimal changeWayQtyEq;
  /**
   * 在途数量变更 比较(neq)
   */
  private java.math.BigDecimal changeWayQtyNeq;
  /**
   * 在途数量变更 比较(gt)
   */
  private java.math.BigDecimal changeWayQtyGt;
  /**
   * 在途数量变更 比较(gte)
   */
  private java.math.BigDecimal changeWayQtyGte;
  /**
   * 在途数量变更 比较(lt)
   */
  private java.math.BigDecimal changeWayQtyLt;
  /**
   * 在途数量变更 比较(lte)
   */
  private java.math.BigDecimal changeWayQtyLte;
  /**
   * 在途数量变更 比较(contains)
   */
  private java.math.BigDecimal changeWayQtyContains;
  /**
   * 在途数量变更 比较(notcontains)
   */
  private java.math.BigDecimal changeWayQtyNotcontains;
  /**
   * 在途数量变更 比较(startswith)
   */
  private java.math.BigDecimal changeWayQtyStartswith;
  /**
   * 在途数量变更 比较(endswith)
   */
  private java.math.BigDecimal changeWayQtyEndswith;
  /**
   * 在途数量变更 比较(isnull)
   */
  private Boolean changeWayQtyIsnull;
  /**
   * 在途数量变更 比较(isnotnull)
   */
  private Boolean changeWayQtyIsnotnull;

  /**
   * 库存数量
   */
  private java.math.BigDecimal stockQty;

  /**
   * 最小库存数量
   */
  private java.math.BigDecimal stockQtyMin;

  /**
   * 最大库存数量
   */
  private java.math.BigDecimal stockQtyMax;

  /**
   * 库存数量 比较(eq)
   */
  private java.math.BigDecimal stockQtyEq;
  /**
   * 库存数量 比较(neq)
   */
  private java.math.BigDecimal stockQtyNeq;
  /**
   * 库存数量 比较(gt)
   */
  private java.math.BigDecimal stockQtyGt;
  /**
   * 库存数量 比较(gte)
   */
  private java.math.BigDecimal stockQtyGte;
  /**
   * 库存数量 比较(lt)
   */
  private java.math.BigDecimal stockQtyLt;
  /**
   * 库存数量 比较(lte)
   */
  private java.math.BigDecimal stockQtyLte;
  /**
   * 库存数量 比较(contains)
   */
  private java.math.BigDecimal stockQtyContains;
  /**
   * 库存数量 比较(notcontains)
   */
  private java.math.BigDecimal stockQtyNotcontains;
  /**
   * 库存数量 比较(startswith)
   */
  private java.math.BigDecimal stockQtyStartswith;
  /**
   * 库存数量 比较(endswith)
   */
  private java.math.BigDecimal stockQtyEndswith;
  /**
   * 库存数量 比较(isnull)
   */
  private Boolean stockQtyIsnull;
  /**
   * 库存数量 比较(isnotnull)
   */
  private Boolean stockQtyIsnotnull;

  /**
   * 库存数量变更
   */
  private java.math.BigDecimal changeStockQty;

  /**
   * 最小库存数量变更
   */
  private java.math.BigDecimal changeStockQtyMin;

  /**
   * 最大库存数量变更
   */
  private java.math.BigDecimal changeStockQtyMax;

  /**
   * 库存数量变更 比较(eq)
   */
  private java.math.BigDecimal changeStockQtyEq;
  /**
   * 库存数量变更 比较(neq)
   */
  private java.math.BigDecimal changeStockQtyNeq;
  /**
   * 库存数量变更 比较(gt)
   */
  private java.math.BigDecimal changeStockQtyGt;
  /**
   * 库存数量变更 比较(gte)
   */
  private java.math.BigDecimal changeStockQtyGte;
  /**
   * 库存数量变更 比较(lt)
   */
  private java.math.BigDecimal changeStockQtyLt;
  /**
   * 库存数量变更 比较(lte)
   */
  private java.math.BigDecimal changeStockQtyLte;
  /**
   * 库存数量变更 比较(contains)
   */
  private java.math.BigDecimal changeStockQtyContains;
  /**
   * 库存数量变更 比较(notcontains)
   */
  private java.math.BigDecimal changeStockQtyNotcontains;
  /**
   * 库存数量变更 比较(startswith)
   */
  private java.math.BigDecimal changeStockQtyStartswith;
  /**
   * 库存数量变更 比较(endswith)
   */
  private java.math.BigDecimal changeStockQtyEndswith;
  /**
   * 库存数量变更 比较(isnull)
   */
  private Boolean changeStockQtyIsnull;
  /**
   * 库存数量变更 比较(isnotnull)
   */
  private Boolean changeStockQtyIsnotnull;
}
